#include <mm32_device.h>
#include <stdio.h>
#include <stdlib.h>  // 必须包含
#include <string.h>
#include "cJSON.h"
#include "cJSON_Utils.h"
#include "ESP8266.h"



#define RX_BUFFER_SIZE 128
uint8_t Serial_RxPacket[RX_BUFFER_SIZE]; // 定义接收数据包数组
char MQTT_Data[RX_BUFFER_SIZE];
volatile uint8_t RxState = 0;                     // 接收状态机状态
uint8_t Serial_RxFlag;					//定义接收数据包标志位
uint8_t pRxPacket = 0;                  //定义表示当前接收数据位置

void ESP8266_Init(void)
{
	GPIO_InitTypeDef  GPIO_InitStruct;
    NVIC_InitTypeDef  NVIC_InitStruct;
    USART_InitTypeDef USART_InitStruct;

    RCC_APB1PeriphClockCmd(RCC_APB1Periph_USART2, ENABLE);

    USART_StructInit(&USART_InitStruct);
    USART_InitStruct.USART_BaudRate   = 115200;
    USART_InitStruct.USART_WordLength = USART_WordLength_8b;
    USART_InitStruct.USART_StopBits   = USART_StopBits_1;
    USART_InitStruct.USART_Parity     = USART_Parity_No;
    USART_InitStruct.USART_Mode       = USART_Mode_Rx | USART_Mode_Tx;
    USART_InitStruct.USART_HardwareFlowControl = USART_HardwareFlowControl_None;
    USART_Init(USART2, &USART_InitStruct);

    RCC_AHBPeriphClockCmd(RCC_AHBPeriph_GPIOA, ENABLE);
    RCC_AHBPeriphClockCmd(RCC_AHBPeriph_GPIOB, ENABLE);

    GPIO_PinAFConfig(GPIOA, GPIO_PinSource8, GPIO_AF_3);
    GPIO_PinAFConfig(GPIOB, GPIO_PinSource8, GPIO_AF_4);

    GPIO_StructInit(&GPIO_InitStruct);
    GPIO_InitStruct.GPIO_Pin   = GPIO_Pin_8;
    GPIO_InitStruct.GPIO_Speed = GPIO_Speed_High;
    GPIO_InitStruct.GPIO_Mode  = GPIO_Mode_AF_PP;
    GPIO_Init(GPIOA, &GPIO_InitStruct);

    GPIO_StructInit(&GPIO_InitStruct);
    GPIO_InitStruct.GPIO_Pin   = GPIO_Pin_8;
    GPIO_InitStruct.GPIO_Mode  = GPIO_Mode_FLOATING;
    GPIO_Init(GPIOB, &GPIO_InitStruct);

    NVIC_InitStruct.NVIC_IRQChannel = USART2_IRQn;
    NVIC_InitStruct.NVIC_IRQChannelPriority = 0;
    NVIC_InitStruct.NVIC_IRQChannelCmd = ENABLE;
    NVIC_Init(&NVIC_InitStruct);

	USART_ITConfig(USART2, USART_IT_RXNE, ENABLE);
	USART_ITConfig(USART2, USART_IT_IDLE, ENABLE);

    USART_Cmd(USART2, ENABLE);
}


void ESP8266_SendByte(uint16_t Byte)
{
    USART_SendData(USART2, Byte);		//将字节数据写入数据寄存器，写入后USART自动生成时序波形
	while(USART_GetFlagStatus(USART2, USART_FLAG_TXE) == RESET);	//等待发送完成
	/*下次写入数据寄存器会自动清除发送完成标志位，故此循环后，无需清除标志位*/
	USART_ClearITPendingBit(USART2, USART_IT_RXNE);
}

void ESP8266_SendString(char *String)
{
    USART_ITConfig(USART2, USART_IT_RXNE, DISABLE); // 禁用接收中断
    while (*String != '\0') {
        ESP8266_SendByte(*String++);
    }
    USART_ITConfig(USART2, USART_IT_RXNE, ENABLE); // 重新启用接收中断
}


// 发送AT指令示例
void ESP8266_AT_Command(char *cmd) {
	printf("\r\n AT_Command = %s", cmd);
    char temp[RX_BUFFER_SIZE];
    snprintf(temp, sizeof(temp), "%s\r\n", cmd); // 安全拼接
    ESP8266_SendString(temp); // 发送命令
}


void Clear_MQTT_Data()
{
    memset(MQTT_Data, 0, sizeof(MQTT_Data));
}


// 函数：提取以 { 开头、以 } 结尾的数据
char* extract_bracket_data(char* input_str) {
    if (input_str == NULL) {return NULL;}

    // 1. 定位第一个 '{' 的位置
    const char* start = strchr(input_str, '{');
    if (start == NULL) {
        return NULL; // 没有找到 '{'
    }

    // 2. 从 start 开始查找对应的 '}'
    const char* end = strchr(start, '}');
    if (end == NULL) {
        return NULL; // 没有找到 '}'
    }

    // 3. 计算子字符串长度（包括 '{' 和 '}'）
    size_t length = end - start + 1;

    // 4. 分配内存并复制数据
    char* result = (char*)malloc(length + 1); // +1 用于终止符
    if (result == NULL) {
        return NULL; // 内存分配失败
    }

    strncpy(result, start, length);
    result[length] = '\0'; // 确保字符串以 '\0' 结尾

    return result;
}


void Parse_MQTT_Data()
{
	printf("Mqtt_Data:%s", Serial_RxPacket);
	Clear_MQTT_Data();
    char temp_buffer[RX_BUFFER_SIZE];
    memcpy(temp_buffer, (char *)Serial_RxPacket, RX_BUFFER_SIZE);
	memset(Serial_RxPacket, 0, sizeof(Serial_RxPacket));
    temp_buffer[RX_BUFFER_SIZE - 1] = '\0'; // 确保字符串以 '\0' 结尾
    char * mqtt_ploay = extract_bracket_data(temp_buffer);
    if(mqtt_ploay)
    {
        cJSON *root = cJSON_Parse(mqtt_ploay);
        if (!root) {
            cJSON_Delete(root);
            return;
        }
        cJSON *item = cJSON_GetObjectItemCaseSensitive(root, "message");
        if (item && cJSON_IsString(item)) {
            strncpy(MQTT_Data, cJSON_GetStringValue(item), sizeof(MQTT_Data) - 1); // 防止缓冲区溢出
            MQTT_Data[sizeof(MQTT_Data) - 1] = '\0'; // 确保字符串以 '\0' 结尾
        }
        item = cJSON_GetObjectItemCaseSensitive(root, "MESSAGE");
        if (item && cJSON_IsString(item)) {
            strncpy(MQTT_Data, cJSON_GetStringValue(item), sizeof(MQTT_Data) - 1); // 防止缓冲区溢出
            MQTT_Data[sizeof(MQTT_Data) - 1] = '\0'; // 确保字符串以 '\0' 结尾
        }
        cJSON_Delete(item); // 释放 item 对象
        cJSON_Delete(root); // 释放 root 对象
        free(mqtt_ploay); // 释放提取的数据内存
    }
	
}


void USART2_IRQHandler(void)
{
    uint8_t RxData;
    if (USART_GetITStatus(USART2, USART_IT_RXNE) != RESET) {
		RxState = 1;
        RxData = USART_ReceiveData(USART2);
		Serial_RxPacket[pRxPacket++] = RxData;
        // 清除中断标志位
        USART_ClearITPendingBit(USART2, USART_IT_RXNE);
    }
	if (USART_GetITStatus(USART2, USART_IT_IDLE) != RESET) {
        RxData = USART_ReceiveData(USART2);
        // 清除中断标志位
        USART_ClearITPendingBit(USART2, USART_IT_IDLE);
		if(RxState > 0)
		{
			USART_ITConfig(USART2, USART_IT_RXNE, DISABLE); 
			USART_ITConfig(USART2, USART_IT_IDLE, DISABLE); 
			RxState = 0;
			pRxPacket = 0;
			Parse_MQTT_Data();
			USART_ITConfig(USART2, USART_IT_RXNE, ENABLE); 
			USART_ITConfig(USART2, USART_IT_IDLE, ENABLE); 
		}
    }
}
